#include "sqloperator.h"
#include <QSqlError>
#include <QSqlDriver>
#include <QRandomGenerator>
#include <QDebug>
/**
 * @brief 构造函数，初始化数据库操作对象
 */
SqlOperator::SqlOperator() {}


int SqlOperator::getrandomgear(int legth)
{
    uint32_t result;
    // 确保生成的随机数不为0
    do {
        result = QRandomGenerator::global()->generate();
    } while (result == 0);
    return result%legth+1;
}

int SqlOperator::getrandomoster(int legth)
{
    uint32_t result;
    // 确保生成的随机数不为0
    do {
        result = QRandomGenerator::global()->generate();
    } while (result == 0);

    return result%legth+1;

}

/**
 * @brief 打开数据库连接
 * 若指定名称的连接已存在则复用，否则创建新连接
 * @param dbName 数据库文件路径
 * @param connectName 连接名称
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::open(const QString &dbName, const QString &connectName) {
    // 检查连接是否已存在
    if (QSqlDatabase::connectionNames().contains(connectName)) {
        m_db = QSqlDatabase::database(connectName);
    } else {
        // 创建新的SQLite连接
        m_db = QSqlDatabase::addDatabase("QSQLITE", connectName);
    }
    m_connectName = connectName;

    // 确保关闭已打开的连接
    if (m_db.isOpen()) {
        m_db.close();
    }

    // 设置数据库文件名并打开
    m_db.setDatabaseName(dbName);
    if (m_db.open()) {
        m_query = QSqlQuery(m_db);  // 关联查询对象到当前数据库
        return true;
    }

    // 记录错误信息
    m_lastError = m_db.lastError().text();
    return false;
}

/**
 * @brief 关闭数据库连接
 */
void SqlOperator::close() {
    m_db.close();
}

/**
 * @brief 获取当前连接名称
 * @return 连接名称
 */
QString SqlOperator::getConnectName() const {
    return m_connectName;
}

/**
 * @brief 检查表是否存在
 * @param tableName 表名
 * @return 存在返回true，否则返回false
 */
bool SqlOperator::isExistTable(const QString &tableName) {
    return m_db.tables().contains(tableName);
}

/**
 * @brief 创建数据表
 * @param tableName 表名
 * @param fields 字段名和类型的哈希表
 * @param pks 主键字段列表
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::createTable(const QString &tableName, const QHash<QString, QString> &fields, const QList<QString> &pks) {
    // 检查表是否已存在
    if (isExistTable(tableName)) {
        m_lastError = QString("Table [%1] already exists").arg(tableName);
        return false;
    }

    // 构建CREATE TABLE语句
    QString sql = QString("CREATE TABLE %1 (").arg(tableName);
    // 添加字段定义
    for (auto iter = fields.begin(); iter != fields.end(); ++iter) {
        sql.append(QString("%1 %2, ").arg(iter.key(), iter.value()));
    }
    // 添加主键定义
    sql.append("PRIMARY KEY (");
    for (const auto &pk : pks) {
        sql.append(QString("%1, ").arg(pk));
    }
    // 移除末尾多余的逗号和空格
    sql.remove(sql.length() - 2, 2);
    sql.append("))");

    // 执行创建表语句
    if (m_query.exec(sql)) {
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}

/**
 * @brief 获取表中符合条件的单个值
 * 核心功能：支持查询任意表中的任意字段值
 * @param tableName 表名
 * @param targetField 需要返回的目标字段名
 * @param whereConditions 查询条件哈希表
 * @return 成功返回查询到的值，失败返回无效的QVariant
 */
QVariant SqlOperator::getSingleValue(const QString &tableName, const QString &targetField,
                                    const QHash<QString, QVariant> &whereConditions) {
    // 校验表和字段是否存在
    QList<QString> checkFields = whereConditions.keys();
    checkFields.append(targetField);
    if (!checkTableInfo(tableName, checkFields)) {
        return QVariant();  // 校验失败返回无效值
    }

    // 构建SELECT查询语句
    QString sql = QString("SELECT %1 FROM %2 WHERE ").arg(targetField, tableName);
    // 添加查询条件
    for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
        sql.append(QString("%1 = ? AND ").arg(iter.key()));
    }
    // 移除末尾多余的" AND "
    sql.remove(sql.length() - 5, 5);

    // 准备查询并绑定参数（防止SQL注入）
    m_query.prepare(sql);
    for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
        m_query.addBindValue(iter.value());
    }

    // 执行查询并获取结果
    if (!m_query.exec() || !m_query.next()) {
        m_lastError = m_query.lastError().text();
        return QVariant();
    }

    // 返回查询到的字段值
    return m_query.value(targetField);
}

/**
 * @brief 查询表中所有数据
 * @param tableName 表名
 * @param fields 需要查询的字段列表
 * @param data 输出参数，存储查询结果
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::selectData(const QString &tableName, const QList<QString> &fields, QList<QVariantList> &data) {
    // 校验表和字段
    if (!checkTableInfo(tableName, fields)) {
        return false;
    }

    // 构建查询语句
    QString sql = "SELECT ";
    for (const auto &field : fields) {
        sql.append(QString("%1, ").arg(field));
    }
    // 移除末尾多余的逗号和空格
    sql.remove(sql.length() - 2, 2);
    sql.append(QString(" FROM %1").arg(tableName));

    // 执行查询
    if (m_query.exec(sql)) {
        // 遍历结果集
        while (m_query.next()) {
            QVariantList row;
            for (const auto &field : fields) {
                row.append(m_query.value(field));
            }
            data.append(row);
        }
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}

/**
 * @brief 带条件查询表中数据
 * @param tableName 表名
 * @param fields 需要查询的字段列表
 * @param whereConditions 查询条件哈希表
 * @param data 输出参数，存储查询结果
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::selectData(const QString &tableName, const QList<QString> &fields,
                           const QHash<QString, QVariant> &whereConditions, QList<QVariantList> &data) {
    // 校验表和字段
    QList<QString> checkFields = fields + whereConditions.keys();
    if (!checkTableInfo(tableName, checkFields)) {
        return false;
    }

    // 构建查询语句（按fields列表顺序指定查询字段）
    QString sql = "SELECT ";
    for (const auto &field : fields) {
        sql.append(QString("%1, ").arg(field));
    }
    sql.remove(sql.length() - 2, 2);
    sql.append(QString(" FROM %1 WHERE ").arg(tableName));

    // 添加查询条件
    for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
        sql.append(QString("%1 = ? AND ").arg(iter.key()));
    }
    sql.remove(sql.length() - 5, 5);  // 移除末尾多余的" AND "

    // 准备查询并绑定参数
    m_query.prepare(sql);
    for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
        m_query.addBindValue(iter.value());
    }

    // 执行查询并处理结果（按索引取数，与fields顺序严格一致）
    if (m_query.exec()) {
        while (m_query.next()) {
            QVariantList row;
            // 关键修改：按索引而非字段名取数，确保顺序与fields列表一致
            for (int i = 0; i < fields.count(); ++i) {
                row.append(m_query.value(i));  // i对应fields[i]的位置
            }
            data.append(row);
        }
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}


/**
 * @brief 执行自定义SQL语句查询
 * @param sql 自定义SQL查询语句
 * @param fields 需要提取的字段列表
 * @param data 输出参数，存储查询结果
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::selectDataBySql(const QString &sql, const QList<QString> &fields, QList<QVariantList> &data) {
    // 执行自定义SQL
    if (m_query.exec(sql)) {
        // 处理查询结果
        while (m_query.next()) {
            QVariantList row;
            for (const auto &field : fields) {
                row.append(m_query.value(field));
            }
            data.append(row);
        }
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}

/**
 * @brief 插入单行数据
 * @param tableName 表名
 * @param fields 字段列表
 * @param data 对应字段的值列表
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::insertRowData(const QString &tableName, const QList<QString> &fields, const QVariantList &data) {
    // 校验表和字段
    if (!checkTableInfo(tableName, fields)) {
        return false;
    }

    // 构建INSERT语句
    QString sql = QString("INSERT INTO %1 (").arg(tableName);
    for (const auto &field : fields) {
        sql.append(QString("%1, ").arg(field));
    }
    sql.remove(sql.length() - 2, 2);
    sql.append(") VALUES (");
    for (int i = 0; i < fields.count(); ++i) {
        sql.append("?, ");
    }
    sql.remove(sql.length() - 2, 2);
    sql.append(")");

    // 准备插入并绑定参数
    m_query.prepare(sql);
    for (const auto &value : data) {
        m_query.addBindValue(value);
    }

    // 执行插入
    if (m_query.exec()) {
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}

/**
 * @brief 插入多行数据
 * @param tableName 表名
 * @param fields 字段列表
 * @param data 多行数据
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::insertRowsData(const QString &tableName, const QList<QString> &fields, const QList<QVariantList> &data) {
    // 校验表和字段
    if (!checkTableInfo(tableName, fields)) {
        return false;
    }

    // 构建INSERT语句
    QString sql = QString("INSERT INTO %1 (").arg(tableName);
    for (const auto &field : fields) {
        sql.append(QString("%1, ").arg(field));
    }
    sql.remove(sql.length() - 2, 2);
    sql.append(") VALUES ");

    // 构建值占位符
    QString valuePlaceholder;
    for (int i = 0; i < fields.count(); ++i) {
        valuePlaceholder.append("?, ");
    }
    valuePlaceholder.remove(valuePlaceholder.length() - 2, 2);
    valuePlaceholder = "(" + valuePlaceholder + ")";

    // 添加所有行的占位符
    for (int i = 0; i < data.count(); ++i) {
        sql.append(QString("%1, ").arg(valuePlaceholder));
    }
    sql.remove(sql.length() - 2, 2);

    // 准备插入并绑定所有参数
    m_query.prepare(sql);
    for (const auto &row : data) {
        for (const auto &value : row) {
            m_query.addBindValue(value);
        }
    }

    // 执行插入
    if (m_query.exec()) {
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}

/**
 * @brief 更新数据
 * @param tableName 表名
 * @param data 需要更新的字段和值
 * @param whereConditions 更新条件
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::updateData(const QString &tableName, const QHash<QString, QVariant> &data,
                           const QHash<QString, QVariant> &whereConditions) {
    // 校验表和字段
    QList<QString> checkFields = data.keys() + whereConditions.keys();
    if (!checkTableInfo(tableName, checkFields)) {
        return false;
    }

    // 构建UPDATE语句
    QString sql = QString("UPDATE %1 SET ").arg(tableName);
    for (auto iter = data.begin(); iter != data.end(); ++iter) {
        sql.append(QString("%1 = ?, ").arg(iter.key()));
    }
    sql.remove(sql.length() - 2, 2);
    sql.append(" WHERE ");

    // 添加更新条件
    for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
        sql.append(QString("%1 = ? AND ").arg(iter.key()));
    }
    sql.remove(sql.length() - 5, 5);

    // 准备更新并绑定参数
    m_query.prepare(sql);
    // 先绑定更新值，再绑定条件值
    for (auto iter = data.begin(); iter != data.end(); ++iter) {
        m_query.addBindValue(iter.value());
    }
    for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
        m_query.addBindValue(iter.value());
    }

    // 执行更新
    if (m_query.exec()) {
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}

/**
 * @brief 删除数据
 * @param tableName 表名
 * @param whereConditions 删除条件
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::deleteData(const QString &tableName, const QHash<QString, QVariant> &whereConditions) {
    // 校验表（空条件时无需校验字段）
    if (!checkTableInfo(tableName, {})) { // 假设checkTableInfo支持空字段列表校验表存在性
        return false;
    }
    // 若有条件，校验条件字段
    if (!whereConditions.isEmpty()) {
        QList<QString> checkFields = whereConditions.keys();
        if (!checkTableInfo(tableName, checkFields)) {
            return false;
        }
    }

    // 构建DELETE语句
    QString sql = QString("DELETE FROM %1").arg(tableName); // 基础语句不含WHERE

    // 若有条件，拼接WHERE子句
    if (!whereConditions.isEmpty()) {
        sql.append(" WHERE ");
        for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
            sql.append(QString("%1 = ? AND ").arg(iter.key()));
        }
        sql.remove(sql.length() - 5, 5); // 移除最后一个" AND "
    }

    // 准备删除并绑定参数
    m_query.prepare(sql);
    for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
        m_query.addBindValue(iter.value());
    }

    // 执行删除
    if (m_query.exec()) {
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}

/**
 * @brief 执行SQL语句
 * @param sql 要执行的SQL语句
 * @return 成功返回true，失败返回false
 */

bool SqlOperator::exec(const QString &sql) {
    if (m_query.exec(sql)) {
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}

/**
 * @brief 检查数据库是否支持事务
 * @return 支持返回true，不支持返回false
 */
bool SqlOperator::hasTransactions() {
    if (m_query.driver()->hasFeature(QSqlDriver::Transactions)) {
        return true;
    }
    m_lastError = "Database does not support transactions";
    return false;
}

/**
 * @brief 开始事务
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::transaction() {
    return m_db.transaction();
}

/**
 * @brief 提交事务
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::commit() {
    return m_db.commit();
}

/**
 * @brief 回滚事务
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::rollback() {
    return m_db.rollback();
}

/**
 * @brief 获取查询结果的记录数
 * @return 记录数，-1表示获取失败
 */
int SqlOperator::size() {
    int count = -1;
    m_query.first();
    if (m_query.next()) {
        // 检查驱动是否支持直接获取记录数
        if (m_query.driver()->hasFeature(QSqlDriver::QuerySize)) {
            count = m_query.size();
        } else {
            // 不支持的情况下通过移动到最后一条记录获取
            m_query.last();
            count = m_query.at() + 1;
        }
    }
    m_query.first();  // 重置查询位置
    return count;
}

/**
 * @brief 获取表的字段信息
 * @param tableName 表名
 * @param fieldsName 输出参数，存储字段名列表
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::getTableFieldsInfo(const QString &tableName, QList<QString> &fieldsName) {
    // 使用PRAGMA语句获取表信息
    QString sql = QString("PRAGMA table_info('%1')").arg(tableName);
    if (m_query.exec(sql)) {
        // 提取字段名（PRAGMA结果的第2列是字段名）
        while (m_query.next()) {
            fieldsName.append(m_query.value(1).toString());
        }
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}

/**
 * @brief 获取最后执行的SQL语句
 * @return SQL语句
 */
QString SqlOperator::lastQuerySql() {
    return m_query.lastQuery();
}

/**
 * @brief 获取最后发生的错误信息
 * @return 错误信息
 */
QString SqlOperator::lastError() const {
    return m_lastError;
}

/**
 * @brief 检查表和字段是否存在
 * 内部辅助函数，用于验证表和字段的有效性
 * @param tableName 表名
 * @param fields 需要检查的字段列表
 * @return 都存在返回true，否则返回false
 */
bool SqlOperator::checkTableInfo(const QString &tableName, const QList<QString> &fields) {
    // 检查表是否存在
    if (!isExistTable(tableName)) {
        m_lastError = QString("Table [%1] does not exist").arg(tableName);
        return false;
    }

    // 获取表的所有字段
    QList<QString> tableFields;
    if (!getTableFieldsInfo(tableName, tableFields)) {
        return false;
    }

    // 检查所有字段是否都存在于表中
    for (const auto &field : fields) {
        if (!tableFields.contains(field)) {
            m_lastError = QString("Table [%1] has no field [%2]").arg(tableName, field);
            return false;
        }
    }
    return true;
}

/**
 * @brief 创建数据表（参数为QMap，保证字段顺序）
 * @param tableName 表名
 * @param fields 字段名和类型的有序映射（QMap）
 * @param pks 主键字段列表
 * @return 成功返回true，失败返回false
 */
bool SqlOperator::createTable1(const QString &tableName, const QMap<QString, QString> &fields, const QList<QString> &pks) {
    // 检查表是否已存在
    if (isExistTable(tableName)) {
        m_lastError = QString("Table [%1] already exists").arg(tableName);
        return false;
    }

    // 构建CREATE TABLE语句
    QString sql = QString("CREATE TABLE %1 (").arg(tableName);
    // 按QMap顺序添加字段定义（QMap遍历是有序的）
    for (auto iter = fields.begin(); iter != fields.end(); ++iter) {
        sql.append(QString("%1 %2, ").arg(iter.key(), iter.value()));
    }
    // 添加主键定义
    sql.append("PRIMARY KEY (");
    for (const auto &pk : pks) {
        sql.append(QString("%1, ").arg(pk));
    }
    // 移除末尾多余的逗号和空格
    sql.remove(sql.length() - 2, 2);
    sql.append("))");

    // 执行创建表语句
    if (m_query.exec(sql)) {
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;

}
bool SqlOperator::selectData1(const QString &tableName, const QList<QString> &fields,const QMap<QString, QVariant> &whereConditions, QList<QVariantList> &data) {  // 改为QMap
    // 校验表和字段
    QList<QString> checkFields = fields;
    for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
        checkFields.append(iter.key());
    }
    if (!checkTableInfo(tableName, checkFields)) {
        return false;
    }

    // 构建查询语句（按fields列表顺序指定查询字段）
    QString sql = "SELECT ";
    for (const auto &field : fields) {
        sql.append(QString("%1, ").arg(field));
    }
    sql.remove(sql.length() - 2, 2);
    sql.append(QString(" FROM %1 WHERE ").arg(tableName));

    // 添加查询条件（按QMap顺序生成，保证条件顺序固定）
    for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
        sql.append(QString("%1 = ? AND ").arg(iter.key()));
    }
    sql.remove(sql.length() - 5, 5);  // 移除末尾多余的" AND "

    // 准备查询并绑定参数（按QMap顺序绑定，与条件顺序一致）
    m_query.prepare(sql);
    for (auto iter = whereConditions.begin(); iter != whereConditions.end(); ++iter) {
        m_query.addBindValue(iter.value());
    }
    // 执行查询并处理结果（按索引取数，与fields顺序严格一致）
    if (m_query.exec()) {
        while (m_query.next()) {
            QVariantList row;
            for (int i = 0; i < fields.count(); ++i) {
                row.append(m_query.value(i));  // 按索引取数，保证顺序
            }
            data.append(row);
        }
        return true;
    }
    m_lastError = m_query.lastError().text();
    return false;
}


